home *** CD-ROM | disk | FTP | other *** search
/ Aminet 39 / Aminet 39 (2000)(Schatztruhe)[!][Oct 2000].iso / Aminet / game / shoot / Orbit_src.lha / Orbit / source / planet.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-07-04  |  23.9 KB  |  980 lines
  1. /*
  2.     Amiga port by Oliver Gantert
  3.  
  4.     27.04.2000 - fixed some compiler warnings
  5.     21.06.2000 - some glColor3d() changed to glColor3f()
  6. */
  7. /*
  8.  
  9. ORBIT, a freeware space combat simulator
  10. Copyright (C) 1999  Steve Belczyk <steve1@genesis.nred.ma.us>
  11.  
  12. This program is free software; you can redistribute it and/or
  13. modify it under the terms of the GNU General Public License
  14. as published by the Free Software Foundation; either version 2
  15. of the License, or (at your option) any later version.
  16.  
  17. This program is distributed in the hope that it will be useful,
  18. but WITHOUT ANY WARRANTY; without even the implied warranty of
  19. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20. GNU General Public License for more details.
  21.  
  22. You should have received a copy of the GNU General Public License
  23. along with this program; if not, write to the Free Software
  24. Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  25.  
  26. */
  27.  
  28. #include "orbit.h"
  29.  
  30. static float MaterialColor[] = {
  31.   1.0, 1.0, 1.0, 1.0}
  32. ; 
  33. static float specular[] = {
  34.   0.0, 0.0, 0.0, 1.0}
  35. ; 
  36. static float emission[] = {
  37.   0.0, 0.0, 0.0, 1.0}
  38. ;
  39.  
  40. void DrawPlanets()
  41. /*
  42.  *  Draw all the planets
  43.  */
  44. {
  45.   int p;
  46.  
  47.   /* Draw orbits */ 
  48.   if (draw_orbits) DrawOrbits(); 
  49.   
  50.   for (p=0; p<NPLANETS; p++)
  51.   {
  52.     if (!planet[p].hidden) DrawPlanet (p);
  53.   }
  54. }
  55.  
  56. void DrawPlanet (int p)
  57. /*
  58.  *  Draw the pretty planet
  59.  */
  60. {
  61.   double th, r2, v[3];
  62.   int pr;
  63.  
  64.   /* Set color to white, will be modulated with texture */
  65.   if (textures)
  66.   {
  67.     glMaterialfv (GL_FRONT_AND_BACK, GL_DIFFUSE, MaterialColor);
  68.     glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT, MaterialColor);
  69.   }
  70.   else
  71.   {
  72.     glMaterialfv (GL_FRONT_AND_BACK, GL_DIFFUSE, planet[p].color);
  73.     glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT, planet[p].color);
  74.   }
  75.   
  76.   glMaterialfv (GL_FRONT_AND_BACK, GL_SPECULAR, specular); 
  77.   glMaterialfv (GL_FRONT_AND_BACK, GL_EMISSION, emission); 
  78.   glMaterialf  (GL_FRONT_AND_BACK, GL_SHININESS, 0.0); 
  79.  
  80.   glPushMatrix();
  81.  
  82.   /* How far away from view is this planet? */
  83.   Vsub (v, planet[p].pos, player.pos);
  84.   planet[p].absrange2 = Mag2(v);
  85.   planet[p].range2 = r2 = planet[p].absrange2 / planet[p].radius2;
  86.  
  87.   /* Translate to where the planet is */
  88.   Vsub (v, planet[p].pos, player.pos);
  89.   glTranslated (v[0], v[1], v[2]);
  90.   th = fmod (absT, 120.0);
  91.   th = 360.0*th / 120.0;
  92.  
  93.   /* Don't bother with oblicity or rotation if it's just a point */
  94.   if (r2 < 200.0*200.0)
  95.   {
  96.     /* Planet oblicity */
  97.     glRotated (planet[p].oblicity, 1.0, 0.0, 0.0);
  98.  
  99.     /* Moons get their primary's oblicity as well */
  100.     if (planet[p].is_moon)
  101.     {
  102.       pr = planet[p].primary;
  103.       glRotated (planet[pr].oblicity, 1.0, 0.0, 0.0);
  104.     }
  105.   }
  106.  
  107.   glPushMatrix();  /* Save un-rotated matrix */
  108.  
  109.   /* Planet rotation */
  110.   if (r2 < 200.0*200.0) glRotated (th, 0.0, 0.0, 1.0);
  111.  
  112.   if (r2 < 5.0 * 5.0)
  113.   {
  114.     if (textures) glEnable (GL_TEXTURE_2D);
  115.     glBindTexture (GL_TEXTURE_2D, planet[p].texid);
  116.     glCallList (planet[p].list320);
  117.   }
  118.   else if (r2 < 25.0 * 25.0)
  119.   {
  120.     if (textures) glEnable (GL_TEXTURE_2D);
  121.     glBindTexture (GL_TEXTURE_2D, planet[p].texid);
  122.     glCallList (planet[p].list80);
  123.   }
  124.   else if (r2 < 200.0 * 200.0)
  125.   {
  126.     if (textures) glEnable (GL_TEXTURE_2D);
  127.     glBindTexture (GL_TEXTURE_2D, planet[p].texid);
  128.     glCallList (planet[p].list20);
  129.   }
  130.   else if (r2 < (5000.0 * 5000.0))
  131.   {
  132.     glDisable (GL_TEXTURE_2D);
  133.     glDisable (GL_LIGHTING);
  134.     glPointSize (2.0);
  135.     glBegin (GL_POINTS);
  136.     glColor3fv (planet[p].color);
  137.     glVertex3d (0.0, 0.0, 0.0);
  138.     glEnd();
  139.   }
  140.   else if (r2 < (50000.0 * 50000.0))
  141.   {
  142.     glDisable (GL_TEXTURE_2D);
  143.     glDisable (GL_LIGHTING);
  144.     glPointSize (1.0);
  145.     glBegin (GL_POINTS);
  146.     glColor3fv (planet[p].color);
  147.     glVertex3d (0.0, 0.0, 0.0);
  148.     glEnd();
  149.   }
  150.  
  151.   glDisable (GL_TEXTURE_2D);
  152.   glEnable (GL_LIGHTING);
  153.  
  154.   /* Pop rotate matrix */
  155.   glPopMatrix();
  156.  
  157.   glPopMatrix();
  158. }
  159.  
  160. void MakePlanetLists()
  161. /*
  162.  *  Define planet display lists
  163.  */
  164. {
  165.   int p;
  166.  
  167.   for (p=0; p<NPLANETS; p++)
  168.   {
  169.     /* Sun is special */
  170.     if (p == 0)
  171.     {
  172.       MakeSunList();
  173.     }
  174.     else
  175.     {
  176.       MakePlanetList (p);
  177.     }
  178.   }
  179.  
  180.   /* Make orbit lists */
  181.   MakeOrbitLists();
  182. }
  183.  
  184. void MakePlanetList (int p)
  185. /*
  186.  *  Make planet lists for planet p
  187.  */
  188. {
  189.   /* We make three different versions of the planet for display at various
  190.     distances */
  191.   if (glIsList (planet[p].list20)) glDeleteLists (planet[p].list20, 1);
  192.   planet[p].list20 = glGenLists (1);
  193.  
  194.   glNewList (planet[p].list20, GL_COMPILE);
  195.   maxtdiff = 0.47;
  196.   Sphere (planet[p].radius, stacks0, slices0);
  197.   glEndList();
  198.  
  199.   if (glIsList (planet[p].list80)) glDeleteLists (planet[p].list80, 1);
  200.   planet[p].list80 = glGenLists (1);
  201.  
  202.   glNewList (planet[p].list80, GL_COMPILE);
  203.   maxtdiff = 0.609384;
  204.   Sphere (planet[p].radius, stacks1, slices1);
  205.   glEndList();
  206.  
  207.   if (glIsList (planet[p].list320)) glDeleteLists (planet[p].list320, 1);
  208.   planet[p].list320 = glGenLists (1);
  209.  
  210.   glNewList (planet[p].list320, GL_COMPILE);
  211.   maxtdiff = 0.414069;
  212.   Sphere (planet[p].radius, stacks2, slices2);
  213.   glEndList();
  214. }
  215.  
  216. void MakeSunList()
  217. /*
  218.  *  Make Sol's display list
  219.  */
  220. {
  221.   if (glIsList (planet[0].list20)) glDeleteLists (planet[0].list20, 1);
  222.   planet[0].list20 = glGenLists (1);
  223.  
  224.   glNewList (planet[0].list20, GL_COMPILE);
  225.   glDisable (GL_LIGHTING);
  226.   glDisable (GL_TEXTURE_2D);
  227.   glColor3f (0.8, 0.8, 0.6);
  228.   Sphere (planet[0].radius, stacks0, slices0);
  229.   glEnable (GL_TEXTURE_2D);
  230.   glEnable (GL_LIGHTING);
  231.   glEndList();
  232.  
  233.   if (glIsList (planet[0].list80)) glDeleteLists (planet[0].list80, 1);
  234.   planet[0].list80 = glGenLists (1);
  235.  
  236.   glNewList (planet[0].list80, GL_COMPILE);
  237.   glDisable (GL_LIGHTING);
  238.   glDisable (GL_TEXTURE_2D);
  239.   glColor3f (0.8, 0.8, 0.6);
  240.   Sphere (planet[0].radius, stacks1, slices1);
  241.   glEnable (GL_TEXTURE_2D);
  242.   glEnable (GL_LIGHTING);
  243.   glEndList();
  244.  
  245.   if (glIsList (planet[0].list320)) glDeleteLists (planet[0].list320, 1);
  246.   planet[0].list320 = glGenLists (1);
  247.  
  248.   glNewList (planet[0].list320, GL_COMPILE);
  249.   glDisable (GL_LIGHTING);
  250.   glDisable (GL_TEXTURE_2D);
  251.   glColor3f (0.8, 0.8, 0.6);
  252.   Sphere (planet[0].radius, stacks2, slices2);
  253.   glEnable (GL_TEXTURE_2D);
  254.   glEnable (GL_LIGHTING);
  255.   glEndList();
  256. }
  257.  
  258. void ReadPlanetTexture (int p)
  259. /*
  260.  *  Read in the planet's texture
  261.  */
  262. {
  263.   FILE *fd;
  264.   int x, y, c, i;
  265.   char fn[64];
  266.  
  267.   /* Sun is special */
  268.   if (p == 0)
  269.   {
  270.     planet[p].color[0] = planet[p].color[1] = planet[p].color[2] = 1.0;
  271.     return;
  272.   }
  273.  
  274.   /* Zero planet average color */
  275.   planet[p].color[0] = planet[p].color[1] = planet[p].color[2] = 0.0;
  276.  
  277.   /* Get id for this texture */
  278.   if (planet[p].texid == (-1)) glGenTextures (1, &planet[p].texid);
  279.   glBindTexture (GL_TEXTURE_2D, planet[p].texid);
  280.  
  281.   glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
  282.  
  283.   /* Put up a progress message */
  284.   Mprint ("Reading %s", planet[p].texfname);
  285.   Log ("ReadPlanetTexture: Reading texture file %s", planet[p].texfname);
  286.   DrawSplash();
  287.  
  288.   /* Open file */
  289.   sprintf (fn, "maps/%s", planet[p].texfname);
  290.   if (NULL == (fd = fopen (fn, "rb")))
  291.   {
  292.     Log ("ReadPlanetTexture: Can't open %s", planet[p].texfname);
  293.     FinishSound();
  294.     CloseLog();
  295.     exit (0);
  296.   }
  297.  
  298.   /* Read past PPM header */
  299.   while (10 != fgetc(fd));
  300.   while (10 != fgetc(fd));
  301.   while (10 != fgetc(fd));
  302.  
  303.   /* Read in the color data */
  304.   for (y=0; y<256; y++)
  305.   {
  306.     for (x=0; x<256; x++)
  307.     {
  308.       for (i=0; i<3; i++)
  309.       {
  310.         c = fgetc (fd);
  311.         if ( (c < 0) || (c > 255) )
  312.         {
  313.           Log ("ReadPlanetTexture: Error reading texture file %s", planet[p].texfname);
  314.           Log ("ReadPlanetTexture: x,y,i,c; %d %d %d %d", x, y, i, c);
  315.           FinishSound();
  316.           CloseLog();
  317.           exit (0);
  318.         }
  319.  
  320.         planet[p].tex[255-y][x][i] = 0xff & c;
  321.         planet[p].color[i] += (float) c;
  322.       }
  323.     }
  324.   }
  325.  
  326.   /* Compute average color */
  327.   for (i=0; i<3; i++) planet[p].color[i] /= (256.0 * 256.0 * 256.0);
  328.  
  329.   /* Set the texture */
  330.   glTexImage2D (GL_TEXTURE_2D, 0, 3, 256, 256, 0, GL_RGB, GL_UNSIGNED_BYTE, planet[p].tex);
  331.   glTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  332.   glTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  333.   glTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
  334.   glTexParameterf (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  335.   glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
  336.  
  337.   fclose (fd);
  338. }
  339.  
  340. void InitPlanets()
  341. /*
  342.  *  All sorts of planet initialization
  343.  */
  344. {
  345.   int p;
  346.  
  347.   for (p=0; p<NPLANETS; p++)
  348.   {
  349.     planet[p].custom = 1;
  350.     planet[p].texid = (-1);
  351.     planet[p].orbitlist = (-1);
  352.   }
  353.  
  354.   /* Randomize theta for each planet */
  355.   RandomPlanets();
  356.  
  357.   /* Reset planets */
  358.   ResetPlanets();
  359. }
  360.  
  361. void ResetPlanets()
  362. /*
  363.  *  Set planets back to the way they should be at start
  364.  */
  365. {
  366.   int p;
  367.  
  368.   p = 0;
  369.  
  370.   Log ("ResetPlanets: resetting planets");
  371.  
  372.   strcpy (planet[p].name, "Sol");
  373.   strcpy (planet[p].texfname, "sol.ppm");
  374.   planet[p].radius = 696000.000000 / KM_TO_UNITS1;
  375.   planet[p].dist = 0.000000 / KM_TO_UNITS2;
  376.   planet[p].is_moon = 0;
  377.   planet[p].primary = 0;
  378.   planet[p].oblicity = 0.0;
  379.   planet[p].angvel = 0.0;
  380.   p++;
  381.  
  382.   strcpy (planet[p].name, "Mercury");
  383.   strcpy (planet[p].texfname, "mercury.ppm");
  384.   planet[p].radius = 2440.000000 / KM_TO_UNITS1;
  385.   planet[p].dist = (realdistances ? 50.79 : 05.7900002) / KM_TO_UNITS2;
  386.   planet[p].is_moon = 0;
  387.   planet[p].primary = 0;
  388.   planet[p].angvel = 0.004166 / 87.969;
  389.   p++;
  390.  
  391.   strcpy (planet[p].name, "Venus");
  392.   strcpy (planet[p].texfname, "venus.ppm");
  393.   planet[p].radius = 6052.000000 / KM_TO_UNITS1;
  394.   planet[p].dist = (realdistances ? 108.2 : 10.8199997) / KM_TO_UNITS2;
  395.   planet[p].is_moon = 0;
  396.   planet[p].primary = 0;
  397.   planet[p].oblicity = 177.3;
  398.   planet[p].angvel = 0.004166 / 224.7;
  399.   p++;
  400.  
  401.   strcpy (planet[p].name, "Earth");
  402.   strcpy (planet[p].texfname, "earth.ppm");
  403.   planet[p].radius = 6371.000000 / KM_TO_UNITS1;
  404.   planet[p].dist = (realdistances ? 149.6 : 14.9600006) / KM_TO_UNITS2;
  405.   planet[p].is_moon = 0;
  406.   planet[p].primary = 0;
  407.   planet[p].oblicity = 23.45;
  408.   planet[p].angvel = 0.004166 / 365.256;
  409.   p++;
  410.  
  411.   strcpy (planet[p].name, "Moon");
  412.   strcpy (planet[p].texfname, "moon.ppm");
  413.   planet[p].radius = 1737.500000 / KM_TO_UNITS1;
  414.   planet[p].dist = 0.384400 / KM_TO_UNITS2;
  415.   planet[p].is_moon = 1;
  416.   planet[p].primary = 3;
  417.   planet[p].oblicity = 0.0;
  418.   planet[p].angvel = 0.004166 / 27.3;
  419.   p++;
  420.  
  421.   strcpy (planet[p].name, "Mars");
  422.   strcpy (planet[p].texfname, "mars.ppm");
  423.   planet[p].radius = 3390.000000 / KM_TO_UNITS1;
  424.   planet[p].dist = (realdistances ? 227.9 : 22.7899994) / KM_TO_UNITS2;
  425.   planet[p].is_moon = 0;
  426.   planet[p].primary = 0;
  427.   planet[p].oblicity = 25.19;
  428.   planet[p].angvel = 0.004166 / 686.98;
  429.   p++;
  430.  
  431.   strcpy (planet[p].name, "Phobos");
  432.   strcpy (planet[p].texfname, "phobos.ppm");
  433.   planet[p].radius = 13.000000 / KM_TO_UNITS1;
  434.   planet[p].dist = 0.009380 / KM_TO_UNITS2;
  435.   planet[p].is_moon = 1;
  436.   planet[p].primary = 5;
  437.   planet[p].oblicity = 0.0;
  438.   planet[p].angvel = 0.004166 / 0.319;
  439.   p++;
  440.  
  441.   strcpy (planet[p].name, "Deimos");
  442.   strcpy (planet[p].texfname, "deimos.ppm");
  443.   planet[p].radius = 8.000000 / KM_TO_UNITS1;
  444.   planet[p].dist = 0.022340 / KM_TO_UNITS2;
  445.   planet[p].is_moon = 1;
  446.   planet[p].primary = 5;
  447.   planet[p].oblicity = 0.0;
  448.   planet[p].angvel = 0.004166 / 1.262;
  449.   p++;
  450.  
  451.   strcpy (planet[p].name, "Jupiter");
  452.   strcpy (planet[p].texfname, "jupiter.ppm");
  453.   planet[p].radius = 69911.000000 / KM_TO_UNITS1;
  454.   /* planet[p].dist = 77.8400024 / KM_TO_UNITS2; */
  455.   planet[p].dist = (realdistances ? 778.4 : 50.0) / KM_TO_UNITS2;
  456.   planet[p].is_moon = 0;
  457.   planet[p].primary = 0;
  458.   planet[p].oblicity = 3.12;
  459.   planet[p].angvel = 0.004166 / 4332.0;
  460.   p++;
  461.  
  462.   strcpy (planet[p].name, "Io");
  463.   strcpy (planet[p].texfname, "io.ppm");
  464.   planet[p].radius = 1821.000000 / KM_TO_UNITS1;
  465.   planet[p].dist = 0.421000 / KM_TO_UNITS2;
  466.   planet[p].is_moon = 1;
  467.   planet[p].primary = 8;
  468.   planet[p].oblicity = 0.0;
  469.   planet[p].angvel = 0.004166 / 1.769;
  470.   p++;
  471.  
  472.   strcpy (planet[p].name, "Europa");
  473.   strcpy (planet[p].texfname, "europa.ppm");
  474.   planet[p].radius = 1565.000000 / KM_TO_UNITS1;
  475.   planet[p].dist = 0.671000 / KM_TO_UNITS2;
  476.   planet[p].is_moon = 1;
  477.   planet[p].primary = 8;
  478.   planet[p].oblicity = 0.0;
  479.   planet[p].angvel = 0.004166 / 3.552;
  480.   p++;
  481.  
  482.   strcpy (planet[p].name, "Ganymede");
  483.   strcpy (planet[p].texfname, "ganymede.ppm");
  484.   planet[p].radius = 2634.000000 / KM_TO_UNITS1;
  485.   planet[p].dist = 1.070000 / KM_TO_UNITS2;
  486.   planet[p].is_moon = 1;
  487.   planet[p].primary = 8;
  488.   planet[p].oblicity = 0.0;
  489.   planet[p].angvel = 0.004166 / 7.155;
  490.   p++;
  491.  
  492.   strcpy (planet[p].name, "Callisto");
  493.   strcpy (planet[p].texfname, "callisto.ppm");
  494.   planet[p].radius = 2403.000000 / KM_TO_UNITS1;
  495.   planet[p].dist = 1.883000 / KM_TO_UNITS2;
  496.   planet[p].is_moon = 1;
  497.   planet[p].primary = 8;
  498.   planet[p].oblicity = 0.0;
  499.   planet[p].angvel = 0.004166 / 16.69;
  500.   p++;
  501.  
  502.   strcpy (planet[p].name, "Saturn");
  503.   strcpy (planet[p].texfname, "saturn.ppm");
  504.   planet[p].radius = 58232.000000 / KM_TO_UNITS1;
  505.   /* planet[p].dist = 142.7000000 / KM_TO_UNITS2; */
  506.   planet[p].dist = (realdistances ? 1427.0 : 75.0) / KM_TO_UNITS2;
  507.   planet[p].is_moon = 0;
  508.   planet[p].primary = 0;
  509.   planet[p].oblicity = 26.73;
  510.   planet[p].angvel = 0.004166 / 10759.0;
  511.   p++;
  512.  
  513.   strcpy (planet[p].name, "Mimas");
  514.   strcpy (planet[p].texfname, "mimas.ppm");
  515.   planet[p].radius = 198.800003 / KM_TO_UNITS1;
  516.   planet[p].dist = 0.185000 / KM_TO_UNITS2;
  517.   planet[p].is_moon = 1;
  518.   planet[p].primary = 13;
  519.   planet[p].oblicity = 0.0;
  520.   planet[p].angvel = 0.004166 / 0.942;
  521.   p++;
  522.  
  523.   strcpy (planet[p].name, "Enceladus");
  524.   strcpy (planet[p].texfname, "enceladus.ppm");
  525.   planet[p].radius = 249.100006 / KM_TO_UNITS1;
  526.   planet[p].dist = 0.238000 / KM_TO_UNITS2;
  527.   planet[p].is_moon = 1;
  528.   planet[p].primary = 13;
  529.   planet[p].oblicity = 0.0;
  530.   planet[p].angvel = 0.004166 / 1.37;
  531.   p++;
  532.  
  533.   strcpy (planet[p].name, "Tethys");
  534.   strcpy (planet[p].texfname, "tethys.ppm");
  535.   planet[p].radius = 529.900024 / KM_TO_UNITS1;
  536.   planet[p].dist = 0.294000 / KM_TO_UNITS2;
  537.   planet[p].is_moon = 1;
  538.   planet[p].primary = 13;
  539.   planet[p].oblicity = 0.0;
  540.   planet[p].angvel = 0.004166 / 1.888;
  541.   p++;
  542.  
  543.   strcpy (planet[p].name, "Dione");
  544.   strcpy (planet[p].texfname, "dione.ppm");
  545.   planet[p].radius = 560.000000 / KM_TO_UNITS1;
  546.   planet[p].dist = 0.377000 / KM_TO_UNITS2;
  547.   planet[p].is_moon = 1;
  548.   planet[p].primary = 13;
  549.   planet[p].oblicity = 0.0;
  550.   planet[p].angvel = 0.004166 / 2.737;
  551.   p++;
  552.  
  553.   strcpy (planet[p].name, "Rhea");
  554.   strcpy (planet[p].texfname, "rhea.ppm");
  555.   planet[p].radius = 764.000000 / KM_TO_UNITS1;
  556.   planet[p].dist = 0.527000 / KM_TO_UNITS2;
  557.   planet[p].is_moon = 1;
  558.   planet[p].primary = 13;
  559.   planet[p].oblicity = 0.0;
  560.   planet[p].angvel = 0.004166 / 4.518;
  561.   p++;
  562.  
  563.   strcpy (planet[p].name, "Titan");
  564.   strcpy (planet[p].texfname, "titan.ppm");
  565.   planet[p].radius = 2575.000000 / KM_TO_UNITS1;
  566.   planet[p].dist = 1.221000 / KM_TO_UNITS2;
  567.   planet[p].is_moon = 1;
  568.   planet[p].primary = 13;
  569.   planet[p].oblicity = 0.0;
  570.   planet[p].angvel = 0.004166 / 15.9;
  571.   p++;
  572.  
  573.   strcpy (planet[p].name, "Iapetus");
  574.   strcpy (planet[p].texfname, "iapetus.ppm");
  575.   planet[p].radius = 718.000000 / KM_TO_UNITS1;
  576.   planet[p].dist = 3.561000 / KM_TO_UNITS2;
  577.   planet[p].is_moon = 1;
  578.   planet[p].primary = 13;
  579.   planet[p].oblicity = 0.0;
  580.   planet[p].angvel = 0.004166 / 79.33;
  581.   p++;
  582.  
  583.   strcpy (planet[p].name, "Uranus");
  584.   strcpy (planet[p].texfname, "uranus.ppm");
  585.   planet[p].radius = 25362.000000 / KM_TO_UNITS1;
  586.   /* planet[p].dist = 287.1000000 / KM_TO_UNITS2; */
  587.   planet[p].dist = (realdistances ? 2871.0 : 100.0) / KM_TO_UNITS2;
  588.   planet[p].is_moon = 0;
  589.   planet[p].primary = 0;
  590.   planet[p].oblicity = 97.86;
  591.   planet[p].angvel = 0.004166 / 30685.0;
  592.   p++;
  593.  
  594.   strcpy (planet[p].name, "Miranda");
  595.   strcpy (planet[p].texfname, "miranda.ppm");
  596.   planet[p].radius = 235.000000 / KM_TO_UNITS1;
  597.   planet[p].dist = 0.130000 / KM_TO_UNITS2;
  598.   planet[p].is_moon = 1;
  599.   planet[p].primary = 21;
  600.   planet[p].oblicity = 0.0;
  601.   planet[p].angvel = 0.004166 / 1.413;
  602.   p++;
  603.  
  604.   strcpy (planet[p].name, "Ariel");
  605.   strcpy (planet[p].texfname, "ariel.ppm");
  606.   planet[p].radius = 580.000000 / KM_TO_UNITS1;
  607.   planet[p].dist = 0.191000 / KM_TO_UNITS2;
  608.   planet[p].is_moon = 1;
  609.   planet[p].primary = 21;
  610.   planet[p].oblicity = 0.0;
  611.   planet[p].angvel = 0.004166 / 2.52;
  612.   p++;
  613.  
  614.   strcpy (planet[p].name, "Umbriel");
  615.   strcpy (planet[p].texfname, "umbriel.ppm");
  616.   planet[p].radius = 585.000000 / KM_TO_UNITS1;
  617.   planet[p].dist = 0.266000 / KM_TO_UNITS2;
  618.   planet[p].is_moon = 1;
  619.   planet[p].primary = 21;
  620.   planet[p].oblicity = 0.0;
  621.   planet[p].angvel = 0.004166 / 4.144;
  622.   p++;
  623.  
  624.   strcpy (planet[p].name, "Titania");
  625.   strcpy (planet[p].texfname, "titania.ppm");
  626.   planet[p].radius = 789.000000 / KM_TO_UNITS1;
  627.   planet[p].dist = 0.436000 / KM_TO_UNITS2;
  628.   planet[p].is_moon = 1;
  629.   planet[p].primary = 21;
  630.   planet[p].oblicity = 0.0;
  631.   planet[p].angvel = 0.004166 / 8.706;
  632.   p++;
  633.  
  634.   strcpy (planet[p].name, "Oberon");
  635.   strcpy (planet[p].texfname, "oberon.ppm");
  636.   planet[p].radius = 761.000000 / KM_TO_UNITS1;
  637.   planet[p].dist = 0.583000 / KM_TO_UNITS2;
  638.   planet[p].is_moon = 1;
  639.   planet[p].primary = 21;
  640.   planet[p].oblicity = 0.0;
  641.   planet[p].angvel = 0.004166 / 13.463;
  642.   p++;
  643.  
  644.   strcpy (planet[p].name, "Neptune");
  645.   strcpy (planet[p].texfname, "neptune.ppm");
  646.   planet[p].radius = 24766.000000 / KM_TO_UNITS1;
  647.   /* planet[p].dist = 449.8000000 / KM_TO_UNITS2; */
  648.   planet[p].dist = (realdistances ? 4498.0 : 125.0) / KM_TO_UNITS2;
  649.   planet[p].is_moon = 0;
  650.   planet[p].primary = 0;
  651.   planet[p].oblicity = 29.56;
  652.   planet[p].angvel = 0.004166 / 60189.0;
  653.   p++;
  654.  
  655.   strcpy (planet[p].name, "Triton");
  656.   strcpy (planet[p].texfname, "triton.ppm");
  657.   planet[p].radius = 1352.599976 / KM_TO_UNITS1;
  658.   planet[p].dist = 0.355000 / KM_TO_UNITS2;
  659.   planet[p].is_moon = 1;
  660.   planet[p].primary = 27;
  661.   planet[p].oblicity = 0.0;
  662.   planet[p].angvel = 0.004166 / -5.877;
  663.   p++;
  664.  
  665.   strcpy (planet[p].name, "Proteus");
  666.   strcpy (planet[p].texfname, "proteus.ppm");
  667.   planet[p].radius = 218.000000 / KM_TO_UNITS1;
  668.   planet[p].dist = 0.118000 / KM_TO_UNITS2;
  669.   planet[p].is_moon = 1;
  670.   planet[p].primary = 27;
  671.   planet[p].oblicity = 0.0;
  672.   planet[p].angvel = 0.004166 / 1.122;
  673.   p++;
  674.  
  675.   strcpy (planet[p].name, "Pluto");
  676.   strcpy (planet[p].texfname, "pluto.ppm");
  677.   planet[p].radius = 1137.000000 / KM_TO_UNITS1;
  678.   /* planet[p].dist = 590.6000000 / KM_TO_UNITS2; */
  679.   planet[p].dist = (realdistances ? 5906.0 : 150.0) / KM_TO_UNITS2;
  680.   planet[p].is_moon = 0;
  681.   planet[p].primary = 0;
  682.   planet[p].oblicity = 122.0;
  683.   planet[p].angvel = 0.004166 / 90465.0;
  684.   p++;
  685.  
  686.   strcpy (planet[p].name, "Charon");
  687.   strcpy (planet[p].texfname, "charon.ppm");
  688.   planet[p].radius = 586.000000 / KM_TO_UNITS1;
  689.   planet[p].dist = 0.019000 / KM_TO_UNITS2;
  690.   planet[p].is_moon = 1;
  691.   planet[p].primary = 30;
  692.   planet[p].oblicity = 0.0;
  693.   planet[p].angvel = 0.004166 / 6.387;
  694.   p++;
  695.  
  696.   /* Randomize planet positions */
  697.   PositionPlanets();
  698.  
  699.   /* Read textures, etc */
  700.   for (p=0; p<NPLANETS; p++)
  701.   {
  702.     if (planet[p].custom)
  703.     {
  704.       ReadPlanetTexture (p);
  705.       planet[p].custom = 0;
  706.     }
  707.  
  708.     planet[p].radius2 = planet[p].radius * planet[p].radius;
  709.     planet[p].hidden = 0;
  710.  
  711.     /* Set planet's mass */
  712.     planet[p].mass = planet[p].radius * planet[p].radius * planet[p].radius;
  713.   }
  714.  
  715.   /* Define planet display lists */
  716.   MakePlanetLists();
  717. }
  718.  
  719. void RandomPlanets()
  720. /*
  721.  *  Randomly set solar angle for each planet
  722.  */
  723. {
  724.   int p;
  725.  
  726.   Log ("RandomPlanets: Randomizing planets");
  727.  
  728.   for (p=0; p<NPLANETS; p++)
  729.   {
  730.     planet[p].theta = 2.0 * rnd (6.28);
  731.   }
  732. }
  733.  
  734. void PositionPlanets()
  735. /*
  736.  *  Turn planet angles into Cartesian coordinates
  737.  */
  738. {
  739.   int p, pr;
  740.   double th, v[3], v1[3];
  741.  
  742.   /* Position the planets */
  743.   for (p=0; p<NPLANETS; p++)
  744.   {
  745.     th = planet[p].theta;
  746.  
  747.     planet[p].pos[0] = planet[p].dist * sin (th);
  748.     planet[p].pos[1] = planet[p].dist * cos (th);
  749.     planet[p].pos[2] = 0.0;
  750.  
  751.     /* If moon, compute absolute position based on primary's
  752.      position and oblicity */
  753.     if (planet[p].is_moon)
  754.     {
  755.       pr = planet[p].primary;
  756.       th = -planet[pr].oblicity * 3.1415926535 / 180.0;
  757.       v[0] = 1.0;
  758.       v[1] = 0.0;
  759.       v[2] = 0.0;
  760.       RotateAbout (v1, planet[p].pos, v, th);
  761.       Vset (planet[p].pos, v1);
  762.       Vadd (planet[p].pos, planet[p].pos, planet[pr].pos);
  763.     }
  764.   }
  765. }
  766.  
  767. int InsidePlanet (double *v)
  768. /*
  769.  *  Check if v is inside a planet.  If yes, return planet
  770.  *  index, else -1
  771.  */
  772. {
  773.   int p;
  774.   double v1[3], r2;
  775.  
  776.   for (p=0; p<NPLANETS; p++)
  777.   {
  778.     if (!planet[p].hidden)
  779.     {
  780.       Vsub (v1, v, planet[p].pos);
  781.       r2 = Mag2 (v1);
  782.  
  783.       /* Inside? */
  784.       if (r2 < planet[p].radius2)
  785.       {
  786.         /* Yep */
  787.         return (p);
  788.       }
  789.     }
  790.   }
  791.  
  792.   /* Nope */
  793.   return (-1);
  794. }
  795.  
  796. void ShowPlanetNames()
  797. {
  798.   int p;
  799.   unsigned char v;
  800.   double v1[3]; 
  801.   char buf[128];
  802.  
  803.   for (p=0; p<NPLANETS; p++)
  804.   {
  805.     if (!planet[p].hidden)
  806.     {
  807.       if (planet[p].is_moon)
  808.       glColor3f (0.0, 0.8, 0.8);
  809.       else
  810.       glColor3f (0.0, 0.0, 0.8);
  811.  
  812.       Vsub (v1, planet[p].pos, player.pos);
  813.       glRasterPos3dv (v1);
  814.       glGetBooleanv (GL_CURRENT_RASTER_POSITION_VALID, &v);
  815.       if (v)
  816.       {
  817.         if (!planet[p].is_moon)
  818.         {
  819.           if (planet[p].absrange2 < 100.0*planet[p].radius*planet[p].radius) 
  820.           {
  821.             sprintf (buf, "%s:%.0lf", planet[p].name, 
  822.             KM_TO_UNITS1*(sqrt(planet[p].absrange2)-planet[p].radius)); 
  823.           }
  824.           else 
  825.           {
  826.             strcpy (buf, planet[p].name); 
  827.           }
  828.           Print (GLUT_BITMAP_HELVETICA_10, buf);
  829.         }
  830.         else
  831.         {
  832.           if (planet[p].range2 < (2000.0 * 2000.0))
  833.           {
  834.             if (planet[p].absrange2 < 100.0*planet[p].radius*planet[p].radius) 
  835.             {
  836.               sprintf (buf, "%s:%.0lf", planet[p].name, 
  837.               KM_TO_UNITS1*(sqrt(planet[p].absrange2)-planet[p].radius)); 
  838.             }
  839.             else 
  840.             {
  841.               strcpy (buf, planet[p].name); 
  842.             }
  843.             Print (GLUT_BITMAP_HELVETICA_10, buf);
  844.           }
  845.         }
  846.       }
  847.     }
  848.   }
  849. }
  850.  
  851. void Sphere (double r, int slices, int sectors)
  852. {
  853.   GLUquadricObj *obj;
  854.  
  855.   obj = gluNewQuadric();
  856.   
  857.   gluQuadricDrawStyle (obj, GLU_FILL);
  858.   gluQuadricNormals (obj, GLU_SMOOTH);
  859.   gluQuadricTexture (obj, GL_TRUE);
  860.   gluSphere (obj, (float)r, sectors, slices);
  861. }
  862.  
  863. int FindPlanetByName (char *c)
  864. /*
  865.  *  Find planet given name, else -1
  866.  */
  867. {
  868.   int p;
  869.  
  870.   for (p=0; p<NPLANETS; p++)
  871.   {
  872.     if (!strcasecmp (c, planet[p].name)) return (p);
  873.   }
  874.  
  875.   return (-1);
  876. }
  877.  
  878. void MakeOrbitLists()
  879. /*
  880.  *  Construct display lists for orbits
  881.  */
  882. {
  883.   int p;
  884.   double th, d, s, c;
  885.  
  886.   d = 360.0 / ((double) ORBIT_SECTORS);
  887.  
  888.   /* Loop through planets */
  889.   for (p=1; p<NPLANETS; p++)
  890.   {
  891.     /* Delete old list */
  892.     if (glIsList (planet[p].orbitlist)) glDeleteLists (planet[p].orbitlist, 1);
  893.  
  894.     /* Make new list */
  895.     planet[p].orbitlist = glGenLists (1);
  896.     glNewList (planet[p].orbitlist, GL_COMPILE);
  897.  
  898.     glBegin (GL_LINE_LOOP);
  899.  
  900.     /* Set color */
  901.     if (planet[p].is_moon)
  902.     {
  903.       glColor3f (0.0, 0.8, 0.8);
  904.     }
  905.     else
  906.     {
  907.       glColor3f (0.0, 0.0, 1.0);
  908.     }
  909.  
  910.     /* Loop through circle */
  911.     for (th=0.0; th<360.0; th+=d)
  912.     {
  913.       s = sin (th*3.1415926535/180.0);
  914.       c = cos (th*3.1415926535/180.0);
  915.  
  916.       glVertex3d (planet[p].dist*s, planet[p].dist*c, 0.0);
  917.     }
  918.  
  919.     glEnd();
  920.     glEndList();
  921.   }
  922. }
  923.  
  924. void DrawOrbits()
  925. /*
  926.  *  Draw orbital paths
  927.  */
  928. {
  929.   int p;
  930.   double v[3];
  931.  
  932.   glDisable (GL_TEXTURE_2D);
  933.   glDisable (GL_LIGHTING);
  934.  
  935.   glPushMatrix();
  936.   Vsub (v, planet[0].pos, player.pos);
  937.   glTranslated (v[0], v[1], v[2]);
  938.  
  939.   for (p=1; p<NPLANETS; p++)
  940.   {
  941.     if (!planet[p].hidden)
  942.     {
  943.       if (planet[p].is_moon)
  944.       {
  945.         if (planet[planet[p].primary].range2 > 200.0*200.0) continue;
  946.  
  947.         glPushMatrix();
  948.         Vsub (v, player.pos, planet[0].pos);
  949.         glTranslated (v[0], v[1], v[2]);
  950.  
  951.         Vsub (v, planet[planet[p].primary].pos, player.pos);
  952.         glTranslated (v[0], v[1], v[2]);
  953.  
  954.         glRotated (planet[planet[p].primary].oblicity, 1.0, 0.0, 0.0);
  955.       }
  956.       glCallList (planet[p].orbitlist);
  957.       if (planet[p].is_moon) glPopMatrix();
  958.     }
  959.   }
  960.  
  961.   glPopMatrix();
  962. }
  963.  
  964. void MovePlanets()
  965. /*
  966.  *  Move planets in their orbits
  967.  */
  968. {
  969.   int p;
  970.  
  971.   for (p=1; p<NPLANETS; p++)
  972.   {
  973.     planet[p].theta -= planet[p].angvel * deltaT * compression 
  974.     * 3.1415926535 / 180.0; 
  975.     if (planet[p].theta < 0.0) planet[p].theta += 2.0 * 3.1415926535; 
  976.   }
  977.  
  978.   PositionPlanets();
  979. }
  980.